package com.xmx.ndmallwxapi.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


import javax.annotation.PostConstruct;

import static com.xmx.common.rabbitDto.OrderDto.*;
@Configuration
@Slf4j
public class RabbitConfig {

    public static class RabbitForOrderConfig{
//        @Autowired
//        RabbitTemplate rabbitTemplate;
        /**
         * 如果发送的消息是一个对象，会使用序列化机制，由MessageConverter转换器处理，
         * 默认是WhiteListDeserializingMessageConverter，使用jdk序列化，所以这些bean必须实现Serializable接口
         *
         * 为了使用json序列化，我们需要往容器中添加一个使用json格式的MessageConverter，发送的消息会标记这个对象的全类名
         *
         * 监听队列的方法参数，可以使用Object obj来接收消息内容，通过obj.getClass()能看到真正类型是 org.springframework.amqp.core.Message
         * 所以也可以直接使用 Message me来接收，通过me.getBody()能够得到消息体
         * 如果知道消息体的本质类型，也可以直接使用 XXXEntity 来接收，
         * @return
         */
        @Bean
        MessageConverter messageConverter() {
            return new Jackson2JsonMessageConverter();
        }
//        @PostConstruct
//        public void setCallback() {
//            /**
//             * 消息由生产者投递到Broker/Exchange回调
//             */
//            rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
//                if (ack) {
//                    log.info("消息投递到交换机成功：[correlationData={}]",correlationData);
//                } else {
//                    log.error("消息投递到交换机失败：[correlationData={}，原因：{}]", correlationData, cause);
//                }
//            });
//            /**
//             * 消息由Exchange路由到Queue失败回调
//             */
//            rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
//                log.error("路由到队列失败，消息内容：{}，交换机：{}，路由件：{}，回复码：{}，回复文本：{}", message, exchange, routingKey, replyCode, replyText);
//            });
//        }
        /**
         * 创建交换机
         */
//        @Bean
//        DirectExchange deadExchang() {
//
//            log.error("1111111111111111111111111111111111111111111");
//            return new DirectExchange(STOCK_EVENT_EXCHANG, true, false);
//        }
//
//        /**
//         * 创建队列
//         */
//
//        @Bean
//        Queue stock_relese_queue() {
//
//            return QueueBuilder.durable(STOCK_RELESE_QUEUE) // durable: 是否持久化
//                    .exclusive() // exclusive: 是否排它
//                    .autoDelete() // autoDelete: 是否自动删除
//                    .ttl(6*10*1000) // 设置队列里的默认过期时间为 60 秒
//                    .deadLetterExchange(STOCK_EVENT_EXCHANG)
//                    .deadLetterRoutingKey(STOCK_DELAY_ROUTING)
//                    .build();
//        }
//
//        @Bean
//        Queue stock_delay_queue(){
//            return new Queue(STOCK_DELAY_QUEUE,true,false,false);
//        }
//
//        /**
//         * 绑定
//         */
//        @Bean
//        public Binding releseBinding() {
//            return BindingBuilder.bind(stock_relese_queue()).to(deadExchang()).with(STOCK_RELESE_ROUTING);
//        }
//        @Bean
//        public Binding delayBinding() {
//            return BindingBuilder.bind(stock_delay_queue()).to(deadExchang()).with(STOCK_DELAY_ROUTING);
//        }
//
//    }
}
}
